#pragma once
template<class iterator>
struct ReverseIterator
{
	// 注意：此处typename的作用是明确告诉编译器，Ref是Iterator类中的类型，而不是静态成员变量
	// 否则编译器编译时就不知道Ref是Iterator中的类型还是静态成员变量 
	// 因为静态成员变量也是按照类名::静态成员变量名的方式访问的
	typedef typename iterator::Ref Ref;
	typedef typename iterator::Ptr Ptr;
	typedef ReverseIterator<iterator> Self;
	ReverseIterator(iterator it)
		:_it(it)
	{
	}
	Ref operator*()
	{
		iterator tmp(_it);
		--tmp;
		return *tmp;
	}
	Ptr operator->()
	{
		return &(operator*());
	}
	Self& operator++()
	{
		_it--;
		return *this;
	}
	Self& operator--()
	{
		_it++;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		_it--;
		return tmp;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		_it++;
		return tmp;
	}
	bool operator!=(const Self& l)
	{
		return _it != l._it;
	}
	bool operator==(const Self& l)
	{
		return _it == l._it;
	}
	iterator _it;
};

template<class T>
struct ReverseIterator<T*>
{
	typedef T& Ref;
	typedef T* Ptr;
	typedef ReverseIterator<T*> Self;
	ReverseIterator(T* it)
		:lt(it)
	{
	}
	Ref operator*()
	{
		T* tmp(lt);
		--tmp;
		return *tmp;
	}
	Ptr operator->()
	{
		return &(operator*());
	}
	Self& operator++()
	{
		lt--;
		return *this;
	}
	Self& operator--()
	{
		lt++;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		lt--;
		return tmp;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		lt++;
		return tmp;
	}
	bool operator!=(const Self& l)
	{
		return lt != l.lt;
	}
	bool operator==(const Self& l)
	{
		return lt == l.lt;
	}
	T* lt;
};

template<class T>
struct ReverseIterator<const T*>
{
	typedef const T& Ref;
	typedef const T* Ptr;
	typedef ReverseIterator<const T*> Self;
	ReverseIterator(const T* it)
		:lt(it)
	{
	}
	Ref operator*()
	{
		const T* tmp(lt);
		--tmp;
		return *tmp;
	}
	Ptr operator->()
	{
		return &(operator*());
	}
	Self& operator++()
	{
		lt--;
		return *this;
	}
	Self& operator--()
	{
		lt++;
		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		lt--;
		return tmp;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		lt++;
		return tmp;
	}
	bool operator!=(const Self& l)
	{
		return lt != l.lt;
	}
	bool operator==(const Self& l)
	{
		return lt == l.lt;
	}
	const T* lt;
};